package com.xxx3biji;

import com.xxx2.Employee;
import org.junit.Test;

import javax.accessibility.Accessible;
import java.io.PrintStream;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 方法引用 : 若lambda体中的方法已经实现了，我们可以使用"方法引用"
 *      (可以理解为方法引用是Lambda 表达式的另一种表现形式)
 *
 * 主要有三种语法格式:
 *
 * 对象::实例方法名
 *
 * 类::静态方法名
 *
 * 类::实例方法名
 *
 * 构造器引用  Employee::new
 *
 * 数组引用    String[]::new
 *
 *            ArrayList::new
 */
public class TestLambda02 {


    //Consumer<T> 消费型接口
    @Test
    public void test1(){
        /**
         * 对象::实例方法名
         *
         * 使用条件(参数和返回值一样)
         * void accept(T t);
         *
         * void println(String x);
         */
        Consumer<String> con=(x)-> System.out.println(x);
        con.accept("111");
        PrintStream ps = System.out;
        Consumer<String> co1=ps::println;
        co1.accept("222");
        Consumer<String> co3= System.out::println;
        co3.accept("333");

    }

    //对象::实例方法名
    @Test
    public void test2(){
        Employee employee = new Employee();
        employee.setName("zs");
        employee.setAge(28);
        Supplier<String> sup =()->employee.getName();
        System.out.println(sup.get());

        Supplier<Integer> sup2=employee::getAge;
        System.out.println(sup2.get());
    }

    //类::静态方法名
    @Test
    public void test3(){
        Comparator<Integer> com=(o1,o2)->Integer.compare(o1,o2);

        Comparator<Integer> com2= Integer::compare;

    }

    //类::实例方法名
    @Test
    public void test4(){
        //                             x是调用者 y是参数
        BiPredicate<String,String> bp=(x,y)->x.equals(y);

        BiPredicate<String,String> bp2= String::equals;
    }

    //构造器引用(需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表保持一致!)
    @Test
    public void test5(){

        Supplier<Employee> sup=()->new Employee(12,"张三",30,1000.00);
        System.out.println(sup.get());

        Supplier<Employee> sup2= Employee::new;
        System.out.println(sup2.get());
//-------------------------------------------------------------
        Function<Integer,Employee> emp =x-> new Employee(x);
        System.out.println(emp.apply(10));
        Function<Integer,Employee> emp2 =Employee::new;
        System.out.println(emp2.apply(12));
    }


    //构造器引用(需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表保持一致!)
    @Test
    public void test6(){

        Function<Integer,String[]> emp =x-> new String[x];
        Function<Integer,String[]> emp2 = String[]::new;

    }
}
